package com.itx.gatewayx.utils;

import lombok.extern.slf4j.Slf4j;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

/**
 * 用户工具类
 */
@Slf4j
@Component
public class UserUtils {

    private static final String USER_ID_HEADER = "X-User-Id";
    private static final String USER_NAME_HEADER = "X-User-Name";
    private static final String TOKEN_HEADER = "Authorization";
    private static final String TOKEN_PREFIX = "Bearer ";
    
    // 使用ThreadLocal存储当前请求的用户ID
    private static final ThreadLocal<Long> CURRENT_USER_ID = new ThreadLocal<>();

    /**
     * 设置当前用户ID到ThreadLocal
     * @param userId 用户ID
     */
    public static void setCurrentUserId(Long userId) {
        CURRENT_USER_ID.set(userId);
    }
    
    /**
     * 清除ThreadLocal中的用户ID
     */
    public static void clearCurrentUserId() {
        CURRENT_USER_ID.remove();
    }

    /**
     * 获取当前用户ID
     *
     * @return 用户ID，未登录返回null
     */
    public static Long getCurrentUserId() {
        // 首先尝试从ThreadLocal获取
        Long userId = CURRENT_USER_ID.get();
        if (userId != null) {
            return userId;
        }
        
        // ThreadLocal中没有，返回null
        log.warn("无法获取当前用户ID，请确保在请求上下文中访问");
        return null;
    }

    /**
     * 从请求中获取用户ID
     *
     * @param request WebFlux请求
     * @return 用户ID，未登录返回null
     */
    public static Long getUserIdFromRequest(ServerHttpRequest request) {
        if (request == null) {
            return null;
        }

        String userIdStr = request.getHeaders().getFirst(USER_ID_HEADER);
        if (userIdStr == null || userIdStr.isEmpty()) {
            return null;
        }

        try {
            return Long.parseLong(userIdStr);
        } catch (NumberFormatException e) {
            log.error("解析用户ID失败: {}", userIdStr, e);
            return null;
        }
    }

    /**
     * 从请求中获取用户ID
     *
     * @param exchange WebFlux交换对象
     * @return 用户ID，未登录返回null
     */
    public static Long getUserIdFromExchange(ServerWebExchange exchange) {
        if (exchange == null) {
            return null;
        }
        return getUserIdFromRequest(exchange.getRequest());
    }

    /**
     * 从请求中获取用户ID（响应式）
     *
     * @param exchange WebFlux交换对象
     * @return 用户ID的Mono，未登录返回空Mono
     */
    public static Mono<Long> getUserIdFromExchangeMono(ServerWebExchange exchange) {
        Long userId = getUserIdFromExchange(exchange);
        return userId != null ? Mono.just(userId) : Mono.empty();
    }

    /**
     * 获取当前用户名
     *
     * @return 用户名，未登录返回null
     */
    public static String getCurrentUsername() {
        // 在WebFlux环境中，我们无法直接获取当前请求
        // 这里简化实现，返回null
        return null;
    }

    /**
     * 从请求中获取用户名
     *
     * @param request WebFlux请求
     * @return 用户名，未登录返回null
     */
    public static String getUsernameFromRequest(ServerHttpRequest request) {
        if (request == null) {
            return null;
        }
        return request.getHeaders().getFirst(USER_NAME_HEADER);
    }

    /**
     * 获取当前请求的Token
     *
     * @return Token，未登录返回null
     */
    public static String getCurrentToken() {
        // 在WebFlux环境中，我们无法直接获取当前请求
        // 这里简化实现，返回null
        return null;
    }

    /**
     * 从请求中获取Token
     *
     * @param request WebFlux请求
     * @return Token，未登录返回null
     */
    public static String getTokenFromRequest(ServerHttpRequest request) {
        if (request == null) {
            return null;
        }

        String authHeader = request.getHeaders().getFirst(TOKEN_HEADER);
        if (authHeader == null || !authHeader.startsWith(TOKEN_PREFIX)) {
            return null;
        }

        return authHeader.substring(TOKEN_PREFIX.length());
    }
} 